#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import dialogos
import debugwindow
import SimpleTree
import ifd
import mx
from psycopg2 import connect
import completion
import comunes
from fechas import CDateLocal
from completion import titulo_campos
import subprocess

from strSQL.fermentacion import strSelectFermentacion
from strSQL.fermentacion import strSelectMaceracionFermentacion
from strSQL.fermentacion import strSelectMezclaFermentacion, strSelectDetalleFermentacion
from strSQL.fermentacion import strSelectRelacionFermentacion, strSelectFermentacionRelacion

from strSQL.maceracion import strSelectMaceracionRecepcionUva
from strSQL.maceracion import strSelectMaceracion, strSelectFermentacionMaceracion

from strSQL.mezcla import strSelectMezcla, strSelectFermentacionMezcla
from strSQL.mezcla import strSelectRelacionMezcla, strSelectMezclaRelacion
from strSQL.mezcla import strSelectRelacionEmbotelladoMezcla, strSelectEmbotelladoMezcla
from strSQL.mezcla import strSelectDetalleMezcla #, strSelectRelacionDespachoMezcla

from strSQL.recepcion_uva import strSelectRecepcionUva, strSelectRecepcionUvaMaceracion

from strSQL.embotellado import strSelectEmbotellado, strSelectRelacionMezclaEmbotellado
from strSQL.embotellado import strSelectMezclaEmbotellado

from strSQL.despacho import strSelectDespacho, strSelectEmbotelladoDespacho, strSelectRelacionMezclaDespachoDetalle
from strSQL.despacho import strSelectRelacionMezclaDespacho, strSelectDespachoEmbotellado

import treetohtml
import deglose

etiqueta = ""



def agrega_elemento(modelo, it, codigo, texto, diccionario, porcentaje=100.0):
    return modelo.append(it, (codigo, texto, diccionario, porcentaje))

def crea_cadena(d, cadena=""):
    for j in d:
        dato = d[j]
        titulo = j.replace("_", " ").title()
        a = mx.DateTime.DateTime(1)
        if type(dato) == type(a):
            dato = CDateLocal(dato)
        a = mx.DateTime.TimeDelta(1)
        if type(dato) ==  type(a):
            dato = str(dato)[:5]
        if type(dato) is float:
            dato = comunes.CMon(dato, 2)
        if type(dato) is int:
            dato = comunes.CMon(dato, 0)
        cadena += "<b>%s</b>: %s\n" % (titulo, dato)
    return cadena

def crea_cadena_recepcion(d, cadena=""):
    cadena = ""
    cadena += "<b>Sector:</b> %s\n"  % d["sector"]
    cadena += "<b>Cuartel:</b> %s\n"  % d["cuartel"]
    cadena += "<b>Variedad:</b> %s\n" % d["variedad"]
    cadena += "<b>Kg. total de la mezcla:</b> %s\n" % comunes.CMon(d["total_mezcla"],2)
    cadena += "<b>Kg. aportada en la mezcla:</b> %s\n" % comunes.CMon(d["total_aportado_de_la_recepcion"],2)
    cadena += "<b>%% de Kg. aporte a la mezcla:</b> %s%%\n" % comunes.CMon(d["porcentaje_del_total_en_la_mezcla"],2)
    cadena += "<b>Código recepción:</b> %s\n" % comunes.CMon(d["codigo"],0)
    cadena += "<b>Cantidad de recepción:</b> %s\n" % comunes.CMon(d["cantidad"],2)
    cadena += "<b>%% del aporte de recepción:</b> %s%%\n" % comunes.CMon(d["porcentaje"],2)
    return cadena

def lista_detalle_recepcion(modelo, it, etiqueta, porcentaje=1):
    d = modelo.get_value(it, 2)
    porcentaje = (modelo.get_value(it, 3)/100)
    
    pi = modelo.iter_parent(it)
    while not pi is None:
        porcentaje = (modelo.get_value(pi, 3)/100) * porcentaje
        pi = modelo.iter_parent(pi)

    if "codigo_recepcion_uva" in d.keys():
        cadena = etiqueta.get_label() + "\n"
        cadena = crea_cadena(d, cadena)
        cadena += "<b>Cantidad utilizada</b>: %s\n" %  (d["cantidad_recepcion_uva"] * porcentaje)
        etiqueta.set_markup(cadena)
    else:
        ni = modelo.iter_children(it)
        while not ni is None:
            lista_detalle_recepcion(modelo, ni, etiqueta, porcentaje)
            ni = modelo.iter_next(ni)

def calcula_detalle_recepcion(modelo, it, hacia_atras=True, cursor=None):
    if not hacia_atras:
        return
    ni = modelo.iter_children(it)
    uvas = {}
    key_recepcion = False
    while ni:
        d = modelo.get_value(ni, 2)
        try:
            key_recepcion = modelo.get_value(ni,2).has_key("cantidad_recepcion_uva")
        except:
            key_recepcion = False
            
        parent = modelo.iter_parent(ni)
            
        if modelo.iter_has_child(ni) and not (modelo[ni][1] in ("Aplicaciones", "Controles")):
            ni = modelo.iter_children(ni)
        elif modelo.iter_next(ni) and (modelo[ni][1] in ("Aplicaciones", "Controles")):
            ni = modelo.iter_next(ni)
        elif not modelo.iter_next(ni) and (modelo[ni][1] in ("Aplicaciones", "Controles")):
            ni = modelo.iter_next(modelo.get_iter(modelo.get_path(parent)))
        elif not modelo.iter_has_child(ni) and not key_recepcion:
            ni = modelo.iter_next(ni)
        else:
            try:
                cantidad = d["cantidad_recepcion_uva"]
                cuartel = d["descripcion_cuartel"]
                variedad = d["descripcion_variedad"]
                sector = d["descripcion_sector"]
                codigo = d["codigo_recepcion_uva"]
                porcentaje = (modelo.get_value(ni, 3)/100)
            except:
                return []
            pi = modelo.iter_parent(ni)
            while not pi is None:
                porcentaje = (modelo.get_value(pi, 3)/100) * porcentaje
                pi = modelo.iter_parent(pi)
            
            if codigo in uvas.keys():
                #uvas[codigo]["cantidad"] += cantidad
                uvas[codigo]["porcentaje"] += porcentaje
            else:    
                uvas[codigo] = {"cantidad": cantidad,
                         "cuartel": cuartel,
                         "codigo": codigo,
                         "sector":sector,
                         "variedad":variedad,
                         "porcentaje": porcentaje}
            
            
            #print "recepcion:", codigo
            #print uvas
            ni1 = modelo.iter_next(ni)
            if ni1 is None:
                while ni1 is None and (modelo.get_path(it)!= modelo.get_path(ni)) and ni:
                    ni = modelo.iter_parent(ni)
                    if ni:
                        ni1 = modelo.iter_next(ni)
                if modelo.get_path(it) != modelo.get_path(ni):
                    ni = ni1
            else:
                ni = ni1
        try:
            if modelo.get_path(it) == modelo.get_path(ni):
                ni = None
        except:
            pass
    cantidad = {}
    
    return [uvas[uva] for uva in uvas]

class TrazabilidadAdelante:
    def __init__(self, cursor):
        self.etiqueta = ""
        self.cursor = cursor
        self.porcentajes = {}
        
    def crea_etiqueta(self, d=None, volumen=0.0):
        self.etiqueta = ""
        porcentajes = d
        total = 0
        if d is None:
            return
        for i in porcentajes:
            if "A" in i:
                #self.etiqueta += "<b>Maceración: %s</b> %s Kg.\n" % (i[1:], round((porcentajes["A%s"%i[1:]])))
                self.etiqueta += "<b>Maceración: %s</b> \n" % (i[1:])#, round((porcentajes["A%s"%i[1:]])))
                total+=(porcentajes["A%s"%i[1:]])
            if "F" in i:
                self.etiqueta += "<b>Fermentación: %s</b> \n" % (i[1:])#, round((porcentajes["F%s"%i[1:]])))
                total += (porcentajes["F%s"%i[1:]])
            if "M" in i:
                self.etiqueta += "<b>Mezcla: %s</b> %s \n" % (i[1:], round((porcentajes["M%s"%i[1:]])))
                total += (porcentajes["M%s"%i[1:]])
            if "E" in i:
                self.etiqueta += "<b>Embotellado: %s</b> \n" % (i[1:])#, round((porcentajes["E%s"%i[1:]])))
                total += round((porcentajes["E%s"%i[1:]]))
            if "D" in i:
                self.etiqueta += "<b>Despacho: %s</b> .\n" % (i[1:])#, round((porcentajes["D%s"%i[1:]])))
                total += round((porcentajes["D%s"%i[1:]]))    
        
        self.etiqueta += "\n<b>Total Lt.:</b> %s\n" % round(total)
        
    def adelante_recepcion(self, codigo, porcentaje=1, tab="\t"):
        sql = strSelectMaceracionRecepcionUva.replace("rm.codigo_maceracion", "rm.codigo_recepcion_uva")
        sql = sql.replace("hora_recepcion_uva", "hora_recepcion_uva, rm.codigo_maceracion")
        self.cursor.execute(sql % codigo)
        r = self.cursor.dictfetchall()
        if len(r) == 0:
            return True
        for i in r:
            if self.adelante_maceracion(i['codigo_maceracion'], (i['porcentaje']/100) * porcentaje, tab + "\t"):
                self.etiqueta += "%s %s\n" % (tab, i['cantidad_recepcion_uva'] * (i['porcentaje']/100) * (porcentaje))
                if "A%s" % i['codigo_maceracion'] in self.porcentajes:
                    self.porcentajes["A%s" % i['codigo_maceracion']] += i['cantidad_recepcion_uva'] * (i['porcentaje']/100) * (porcentaje)
                else:
                    self.porcentajes["A%s" % i['codigo_maceracion']] = i['cantidad_recepcion_uva'] * (i['porcentaje']/100) * (porcentaje)
    
    def adelante_maceracion(self, codigo, porcentaje=1, tab="\t"):
        self.cursor.execute(strSelectFermentacionMaceracion % codigo)
        r = self.cursor.dictfetchall()
        if len(r) == 0:
            return True
        for i in r:
            if self.adelante_fermentacion(i['codigo_fermentacion'], (i['porcentaje']/100) * porcentaje, tab + "\t"):
                self.etiqueta += "%s %s\n" % (tab, i['volumen_maceracion'] * (i['porcentaje']/100) * (porcentaje))
                if "F%s" % i['codigo_fermentacion'] in self.porcentajes:
                    self.porcentajes["F%s" % i['codigo_fermentacion']] += i['volumen_maceracion'] * (i['porcentaje']/100) * (porcentaje)
                else:
                    self.porcentajes["F%s" % i['codigo_fermentacion']] = i['volumen_maceracion'] * (i['porcentaje']/100) * (porcentaje)
        #return True
    
    
    def adelante_fermentacion(self, codigo, porcentaje=1, tab="\t"):
        self.cursor.execute(strSelectMezclaFermentacion % codigo)
        r = self.cursor.dictfetchall()
        det = len(r)
        for i in r:
            if self.adelante_mezcla(i['codigo_mezcla'], (i['rendimiento']/100)*(i['porcentaje']/100) * (porcentaje), tab + "\t"):
                self.etiqueta += "%s %s - Rendimiento %s\n" % (tab, i['volumen'] *(i['porcentaje']/100) * (porcentaje), (i['rendimiento']/100))
                if "F%s" % i['codigo_mezcla'] in self.porcentajes:
                    self.porcentajes["M%s" % i['codigo_mezcla']] += i['volumen'] * (i['porcentaje']/100) * (i['rendimiento']/100) * (porcentaje)
                else:
                    self.porcentajes["M%s" % i['codigo_mezcla']] = i['volumen'] * (i['porcentaje']/100) * (i['rendimiento']/100) * (porcentaje)
        
        sql = strSelectDetalleFermentacion.replace("df.codigo_fermentacion", "df.codigo_relacion") % codigo
        sql = sql.replace("df.codigo_relacion = f.codigo_fermentacion", "df.codigo_fermentacion = f.codigo_fermentacion")
        
        self.cursor.execute(sql)
        r = self.cursor.dictfetchall()
        
        det += len(r)
        if det == 0:
            return True
        
        for i in r:
            if self.adelante_fermentacion(i['codigo_fermentacion'], (i['porcentaje']/100) * (porcentaje), tab + "\t"):
                self.etiqueta += "%s %s\n" % (tab, i['volumen'] * (i['porcentaje']/100) * (porcentaje))
                if "F%s" % i['codigo_fermentacion'] in self.porcentajes:
                    self.porcentajes["F%s" % i['codigo_fermentacion']] += i['volumen'] * (i['porcentaje']/100) * (porcentaje)
                else:
                    self.porcentajes["F%s" % i['codigo_fermentacion']] = i['volumen'] * (i['porcentaje']/100) * (porcentaje)
        #return True
    
    #despacho_granel = Variable global usada para saber si un despacho es a granel o no
    despacho_granel = False
    
    def adelante_mezcla(self, codigo, porcentaje=1, tab="\t"):
        # encuentra en que embotellado o mezcla se ha cargado la mezcla
        if codigo is None:
            return False
        
        self.cursor.execute(strSelectEmbotelladoMezcla % codigo)
        r = self.cursor.dictfetchall()
        det = len(r)
        for i in r:
            if self.adelante_embotellado(i['codigo_embotellado'], (i['porcentaje']/100)*porcentaje, tab + "\t"):
                if "E%s" % i['codigo_embotellado'] in self.porcentajes:
                    self.porcentajes["E%s" % i['codigo_embotellado']] += round(i['volumen'] * (i['porcentaje']/100) * (porcentaje))
                else:
                    self.porcentajes["E%s" % i['codigo_embotellado']] = round(i['volumen'] * (i['porcentaje']/100) * (porcentaje))
        
        sql = strSelectRelacionMezclaDespachoDetalle.replace("where md.codigo_despacho =", "where md.codigo_mezcla =")
        self.cursor.execute(sql % codigo)
        r = self.cursor.dictfetchall()
        det += len(r)
        for i in r:
            #if "D%s" % i['codigo_despacho'] in self.porcentajes:
            #    self.porcentajes["D%s" % i['codigo_despacho']] += i['cantidad']
            #else:
            self.porcentajes["D%s" % i['codigo_despacho']] = i['cantidad']
        
        global despacho_granel
        despacho_granel = False        
        if len(r) > 0:
            despacho_granel = True
                
        sql = strSelectDetalleMezcla.replace("dm.codigo_mezcla", "dm.codigo_relacion") % codigo
        sql = sql.replace("dm.codigo_relacion = m.codigo_mezcla", "dm.codigo_mezcla = m.codigo_mezcla")
        self.cursor.execute(sql)
        r = self.cursor.dictfetchall()
        
        det += len(r)
        if det == 0:
            return True
        
        for i in r:
            if self.adelante_mezcla(i['codigo_mezcla'], (i['porcentaje']/100)*porcentaje, tab + "\t"):
                self.etiqueta += "%s %s\n" % (tab, i['volumen'] * (i['porcentaje']/100) * (porcentaje))
                if "M%s" % i['codigo_mezcla'] in self.porcentajes:
                    self.porcentajes["M%s" % i['codigo_mezcla']] += i['volumen'] * (i['porcentaje']/100) * (porcentaje)
                else:
                    self.porcentajes["M%s" % i['codigo_mezcla']] = i['volumen'] * (i['porcentaje']/100) * (porcentaje)
        #return True
    
    def adelante_embotellado(self, codigo, porcentaje=1, tab="\t"):
        if codigo is None:
            return False
        
        sql = strSelectDespachoEmbotellado.replace("where md.codigo_despacho =", "where md.codigo_embotellado =")
        self.cursor.execute(sql % codigo)
        r = self.cursor.dictfetchall()
        det = len(r)
        for i in r:
            if "D%s" % i['codigo_despacho'] in self.porcentajes:
                self.porcentajes["D%s" % i['codigo_despacho']] += i['cantidad']
            else:
                self.porcentajes["D%s" % i['codigo_despacho']] = i['cantidad']

def calcula_trazabilidad_hacia_adelante(codigo=None, tipo=None, cursor=None):
    if codigo is None or tipo is None or cursor is None:
        return
    
def lista_controles(filtro, it, modelo, cursor):
    cursor.execute("""select c.*,
                            t.descripcion_tipo_control,
                            f.descripcion_ficha,
                            u.descripcion_unidad
                        from traza.control c
                        natural join traza.tipo_control t
                        natural join traza.unidad u
                        inner join traza.ficha f
                        on c.rut_responsable = f.rut_ficha where %s""" % filtro)
    campo = filtro.split("=")[0]
    r = cursor.dictfetchall()
    if len(r)>0:
        it = agrega_elemento(modelo, it, "", "Controles", "", 0.0)
    for i in r:
        if i["descripcion_resultado"] in ("", None):
            res = i["resultado_control"]
        else:
            res = i["descripcion_resultado"]
        cadena = "%s Control: %s, Resultado %s %s, Responsable %s" % (
                                                CDateLocal(i["fecha_control"]),
                                                i["descripcion_tipo_control"],
                                                res,
                                                i["descripcion_unidad"],
                                                i["descripcion_ficha"])
        ele = agrega_elemento(modelo, it, "", cadena, "", 0.0)

def lista_aplicaciones(filtro, it, modelo, cursor):
    cursor.execute("""select c.*,
                            p.descripcion_insumo,
                            f.descripcion_ficha,
                            u.descripcion_unidad,
                            ri.numero_documento
                        from traza.aplicacion_producto c
                        natural join traza.recepcion_insumo ri
                        natural join traza.insumo p
                        natural join traza.unidad u
                        inner join traza.ficha f
                            on c.rut_responsable = f.rut_ficha where %s""" % filtro)
    campo = filtro.split("=")[0]
    r = cursor.dictfetchall()
    if len(r)>0:
        it = agrega_elemento(modelo, it, "", "Aplicaciones", "", 0.0)
    for i in r:
        dosis = i["dosis"]
        if dosis is None: dosis = "No especificada."
        cadena = '%s Aplicación: %s Cantidad: %s %s, Dosis: %s Factura: %s Responsable: %s' % (
                                            CDateLocal(i["fecha_aplicacion"]),
                                                        i["descripcion_insumo"],
                                                        i["cantidad"],
                                                        i["descripcion_unidad"],
                                                        dosis,
                                                        i["numero_documento"],
                                                        i["descripcion_ficha"])
        ele = agrega_elemento(modelo, it, "", cadena, i, 0.0)

class DatosRecepcionUva:
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=1.0, hacia_atras=True, hijo=False, arbol=False):
        if codigo is None:
            sql = strSelectRecepcionUva
        else:
            sql = strSelectRecepcionUva.replace("ORDER", "WHERE r.codigo_recepcion_uva = %s ORDER")
            sql = sql % codigo
        cursor.execute(sql)
        self.elementos = []
        self.modelo = modelo
        r = cursor.dictfetchall()
        
        for i in r:
            if not arbol:
                cadena = texto+"Recepción: %s KG de %s %s %s el %s" % (comunes.CMon(i["cantidad_recepcion_uva"], 0),
                            i["descripcion_cuartel"],
                            i["descripcion_sector"],
                            i["descripcion_variedad"],
                            CDateLocal(i["fecha_recepcion_uva"]))
                ele = agrega_elemento(self.modelo, it, i["codigo_recepcion_uva"], cadena, i, porcentaje)
            else:
                ele = it
                
            lista_controles("codigo_recepcion_uva=%s"%i["codigo_recepcion_uva"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_recepcion_uva=%s"%i["codigo_recepcion_uva"], ele, self.modelo, cursor)
                
            if not hacia_atras and (hijo or codigo is None or arbol):
                cursor.execute(strSelectRecepcionUvaMaceracion % i["codigo_recepcion_uva"])
                re = cursor.dictfetchall()
                for j in re:
                    recep = DatosMaceracion(self.modelo,
                                ele,
                                cursor,
                                j["codigo_maceracion"],
                                "%s%% " % j["porcentaje"],
                                j["porcentaje"],
                                hacia_atras, hijo=hijo, arbol=False)

class DatosMaceracion:
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=100.0, hacia_atras=True, hijo=False, arbol=False):
        if codigo is None:
            sql = strSelectMaceracion
        else:
            sql = strSelectMaceracion.replace("ORDER", "WHERE m.codigo_maceracion = %s ORDER")
            sql = sql % codigo
        cursor.execute(sql)
        self.elementos = []
        self.modelo = modelo
        r = cursor.dictfetchall()
        
        for i in r:
            if not arbol:
                cadena = texto+"Maceración: Volumen %s en %s el %s. Observación: %s " % (comunes.CMon(i["volumen_maceracion"],2),
                            i["descripcion_estanque"],
                            CDateLocal(i["fecha_maceracion"]), i["orden_trabajo"])
                ele = agrega_elemento(self.modelo, it, i["codigo_maceracion"], cadena, i, porcentaje)
            else:
                ele = it
                
            lista_controles("codigo_maceracion=%s"%i["codigo_maceracion"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_maceracion=%s"%i["codigo_maceracion"], ele, self.modelo, cursor)
                
            if hijo or codigo is None or arbol:
                if hacia_atras:
                    cursor.execute(strSelectMaceracionRecepcionUva % i["codigo_maceracion"])
                    re = cursor.dictfetchall()
                    for j in re:
                        recep = DatosRecepcionUva(self.modelo, 
                                        ele, 
                                        cursor, 
                                        j["codigo_recepcion_uva"], 
                                        "%s%% " % j["porcentaje"], 
                                        j["porcentaje"],
                                        hacia_atras, hijo=hijo, arbol=False)
                else:
                    cursor.execute(strSelectFermentacionMaceracion % i["codigo_maceracion"])
                    re = cursor.dictfetchall()
                    for j in re:
                        recep = DatosFermentacion(self.modelo, 
                                        ele, 
                                        cursor, 
                                        j["codigo_fermentacion"], 
                                        "%s%% " % j["porcentaje"], 
                                        j["porcentaje"],
                                        hacia_atras, hijo=hijo, arbol=False)

class DatosFermentacion:
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=100.0, hacia_atras=True, hijo=False, arbol=False):
        if codigo is None:
            sql = strSelectFermentacion
        else:
            sql = strSelectFermentacion.replace("ORDER", "WHERE f.codigo_fermentacion = %s ORDER")
            sql = sql % codigo
        cursor.execute(sql)
        self.elementos = []
        self.modelo = modelo
        r = cursor.dictfetchall()
        
        for i in r:
            if not arbol:
                cadena = texto+"Fermentación: Volumen %s en %s el %s. Observación: %s" % (comunes.CMon(i["volumen"],2),
                            i["descripcion_estanque"],
                            CDateLocal(i["fecha_fermentacion"]), i["orden_trabajo"])
                ele = agrega_elemento(self.modelo, it, i["codigo_fermentacion"], cadena, i, porcentaje)
            else:
                ele = it
                
            lista_controles("codigo_fermentacion=%s"%i["codigo_fermentacion"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_fermentacion=%s"%i["codigo_fermentacion"], ele, self.modelo, cursor)
            
            if hijo or codigo is None or arbol:
                if hacia_atras:
                    cursor.execute(strSelectRelacionFermentacion % i["codigo_fermentacion"])
                else:
                    cursor.execute(strSelectFermentacionRelacion % i["codigo_fermentacion"])
                re = cursor.dictfetchall()
                for j in re:
                        recep = DatosFermentacion(self.modelo, 
                                        ele, 
                                        cursor, 
                                        j["codigo_relacion"], 
                                        "%s%% " % j["porcentaje"], 
                                        j["porcentaje"],
                                        hacia_atras, hijo=hijo, arbol=False)
                
                if hacia_atras:
                    cursor.execute(strSelectMaceracionFermentacion % i["codigo_fermentacion"])
                    re = cursor.dictfetchall()
                    for j in re:
                        recep = DatosMaceracion(self.modelo,
                                            ele,
                                            cursor,
                                            j["codigo_maceracion"],
                                            "%s%% " % j["porcentaje"],
                                            j["porcentaje"],
                                            hacia_atras, hijo=hijo, arbol=False)
                else:
                    cursor.execute(strSelectMezclaFermentacion % i["codigo_fermentacion"])
                    re1 = cursor.dictfetchall()
                    for x in re1:
                        recep = DatosMezcla(self.modelo, 
                                        ele, 
                                        cursor, 
                                        x["codigo_mezcla"], 
                                        "%s%% " % x["porcentaje"], 
                                        ((x["porcentaje"]/100)*(x["rendimiento"]/100))*100,
                                        hacia_atras,
                                        x["rendimiento"], hijo=hijo, arbol=False)

class DatosMezcla:
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=100.0, hacia_atras=True, rendimiento=100, hijo=False, arbol=False):
        if codigo is None:
            sql = strSelectMezcla
        else:
            sql = strSelectMezcla.replace("ORDER", "WHERE m.codigo_mezcla = %s ORDER")
            sql = sql % codigo
        cursor.execute(sql)
        self.elementos = []
        self.modelo = modelo
        r = cursor.dictfetchall()
        
        for i in r:
            if not arbol:
                rend = ""
                if not hacia_atras:
                    rend = " Rendimiento %s%%" % rendimiento
                cadena = texto + "Mezcla (%s): Volumen %s en %s el %s %s. Observación: %s" % (i["codigo_proceso"],comunes.CMon(i["volumen"],2),
                            i["descripcion_estanque"],
                            CDateLocal(i["fecha_mezcla"]), rend, i["orden_trabajo"])
                ele = agrega_elemento(self.modelo, it, i["codigo_mezcla"], cadena, i, porcentaje)
            else:
                ele = it

            lista_controles("codigo_mezcla=%s"%i["codigo_mezcla"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_mezcla=%s"%i["codigo_mezcla"], ele, self.modelo, cursor)
            
            if hijo or codigo is None or arbol:
                if hacia_atras:
                    cursor.execute(strSelectRelacionMezcla % i["codigo_mezcla"])
                else:
                    cursor.execute(strSelectMezclaRelacion % i["codigo_mezcla"])
                re = cursor.dictfetchall()
                
                for j in re:
                    recep = DatosMezcla(self.modelo, 
                                ele, 
                                cursor, 
                                j["codigo_relacion"], 
                                "%s%% " % j["porcentaje"], 
                                j["porcentaje"],
                                hacia_atras, hijo=hijo, arbol=False)
                if hacia_atras:
                    cursor.execute(strSelectFermentacionMezcla % i["codigo_mezcla"])
                    re2 = cursor.dictfetchall()
                    for k in re2:
                        recep = DatosFermentacion(self.modelo, 
                            ele, 
                            cursor, 
                            k["codigo_fermentacion"], 
                            "%s%% " % k["porcentaje"], 
                            k["porcentaje"],
                            hacia_atras, hijo=hijo, arbol=False)
                else:
                    cursor.execute(strSelectRelacionEmbotelladoMezcla % i["codigo_mezcla"])
                    re2 = cursor.dictfetchall()
                    for k in re2:
                        recep = DatosEmbotellado(self.modelo, 
                                        ele, 
                                        cursor, 
                                        k["codigo_embotellado"], 
                                        "%s%% " % k["porcentaje"], 
                                        k["porcentaje"],
                                        hacia_atras, hijo=hijo, arbol=False)
                    cursor.execute(strSelectRelacionMezclaDespachoDetalle % i["codigo_mezcla"])
                    re3 = cursor.dictfetchall()
                    #print re3
                    for l in re3:
                        porcentaje = round(((l["cantidad"] * 100)/ l["volumen"] ), 2)
                        recep = DatosDespacho(self.modelo, 
                                        ele, 
                                        cursor, 
                                        l["codigo_despacho"], 
                                        "%s%% " % porcentaje, 
                                        porcentaje,
                                        hacia_atras, hijo=hijo, arbol=False, tipo="litros",
                                        codigo_mezcla=l['codigo_mezcla'])
            
class DatosEmbotellado:
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=100.0, hacia_atras=True, hijo=False, arbol=False):
        if codigo is None:
            sql = strSelectEmbotellado
        else:
            sql = strSelectEmbotellado.replace("ORDER", "WHERE m.codigo_embotellado = %s ORDER")
            sql = sql % codigo
        cursor.execute(sql)
        self.elementos = []
        self.modelo = modelo
        r = cursor.dictfetchall()
        
        for i in r:
            if not arbol:
                cadena = texto + "Embotellado: %s de %s, %s Botellas, Lote: %s. Observación: %s" % (comunes.CMon(i["cantidad"],2),
                            i["descripcion_producto"], i["cantidad_botella"], i["lote"], i["orden_trabajo"])
                ele = agrega_elemento(self.modelo, it, i["codigo_embotellado"], cadena, i, 100.0)
            else:
                ele = it
            
            lista_controles("codigo_embotellado=%s"%i["codigo_embotellado"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_embotellado=%s"%i["codigo_embotellado"], ele, self.modelo, cursor)
                
            if hijo or codigo is None or arbol:
                if hacia_atras:
                    cursor.execute(strSelectRelacionMezclaEmbotellado % i["codigo_embotellado"])
                    re = cursor.dictfetchall()
                    for j in re:
                        recep = DatosMezcla(self.modelo, 
                                ele, 
                                cursor, 
                                j["codigo_mezcla"], 
                                "%s%% " % j["porcentaje"], 
                                j["porcentaje"],
                                hacia_atras, hijo=hijo, arbol=False)
                else:
                    cursor.execute(strSelectDespachoEmbotellado % i["codigo_embotellado"])
                    re2 = cursor.dictfetchall()
                    for k in re2:
                        recep = DatosDespacho(self.modelo, 
                                        ele, 
                                        cursor, 
                                        k["codigo_despacho"], 
                                        "%s botellas " % k["cantidad"], 
                                        k["cantidad"],
                                        hacia_atras, hijo=hijo, arbol=False, tipo="botellas")

class DatosDespacho:
    
    def __init__(self, modelo, it, cursor, codigo, texto="", porcentaje=100.0, hacia_atras=True, hijo=False, arbol=False, tipo=None, codigo_mezcla=None):
        if codigo is None:
            sql = strSelectDespacho
        else:
            sql = strSelectDespacho.replace("ORDER", "WHERE d.codigo_despacho = %s ORDER")
            sql = sql % codigo
            if not codigo_mezcla is None:
                sql = sql.replace("ORDER", "and md.codigo_mezcla = %s ORDER")
                sql = sql % codigo_mezcla
            
        
        if tipo=="botellas":
            sql = sql.replace("FROM", ", ed.cantidad FROM")
            sql = sql.replace("WHERE", """INNER JOIN traza.embotellado_despacho ed
                                            on ed.codigo_despacho = d.codigo_despacho WHERE""")
        elif tipo=="litros":
            sql = sql.replace("FROM", ", md.cantidad FROM")
            sql = sql.replace("WHERE", """INNER JOIN traza.mezcla_despacho md
                                            on md.codigo_despacho = d.codigo_despacho WHERE""")
            
        cursor.execute(sql)
        r = cursor.dictfetchall()
        
        self.elementos = []
        self.modelo = modelo
        
        for i in r:
            if not arbol:
                if tipo is None:
                    cadena = texto + "Despacho: cliente %s en el %s hacia %s. Observación: %s" % (i["descripcion_ficha"],
                            i["fecha_despacho"], i["destino"], i["observaciones"])
                else:
                    cadena = texto + "Despacho: %s %s al cliente %s en el %s hacia %s. Observación: %s" % (i["cantidad"],
                                    tipo, i["descripcion_ficha"], CDateLocal(i["fecha_despacho"]),
                                    i["destino"], i["observaciones"])
                ele = agrega_elemento(self.modelo, it, i["codigo_despacho"], cadena, i, porcentaje)
            else:
                ele = it
                
            lista_controles("codigo_despacho=%s"%i["codigo_despacho"], ele, self.modelo, cursor)
            lista_aplicaciones("codigo_despacho=%s"%i["codigo_despacho"], ele, self.modelo, cursor)
                
            if hacia_atras and (codigo is None or hijo or arbol):
                cursor.execute(strSelectEmbotelladoDespacho% i["codigo_despacho"])
                re = cursor.dictfetchall()
                for j in re:
                    recep = DatosEmbotellado(self.modelo, 
                                    ele, 
                                    cursor, 
                                    j["codigo_embotellado"], 
                                    "%s botellas " % j['cantidad'],
                                    j['cantidad'],
                                    hacia_atras, hijo=hijo, arbol=False)
                    
                cursor.execute(strSelectRelacionMezclaDespacho% i["codigo_despacho"])
                re2 = cursor.dictfetchall()
                for k in re2:
                    recep = DatosMezcla(self.modelo, 
                            ele, 
                            cursor, 
                            k["codigo_mezcla"], 
                            "%s litros " % k['cantidad'],
                            k['cantidad'],
                            hacia_atras, hijo=hijo, arbol=False)

(CODIGO,
 DETALLE) = range(2)

class vboxTrazabilidad(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnTrazabilidad", cargar=True):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnTrazabilidad.maximize()
            self.frm_padre = self.wnTrazabilidad
        else:
            self.frm_padre = self.padre.frm_padre
        
        self.hpanTrazabilidad.set_position(800)
        self.hacia_atras = True
        self.crea_columnas()
        
        self.expand = True
        
        try:
            self.treeTrazabilidad.set_enable_tree_lines(True)
        except:
            pass
        if cargar:
            self.carga_datos()
        
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([0, "Código", str])
        columnas.append ([1, "Detalle", "pango"])
        columnas.append ([3, "%", str])
        
        self.modelo = gtk.TreeStore(str, str, object, float)
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeTrazabilidad)
        self.selection = self.treeTrazabilidad.get_selection()
        self.selection.connect('changed', self.selection_changed)
        self.col_data = [x[0] for x in columnas]
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeTrazabilidad,"Arbol de Trazabilidad", self.col_data)
        t.show()
        
    def carga_child(self, treeView, iter, tuple):
        modelo = treeView.get_model()
        d = modelo[iter][2]
        
        if modelo.iter_parent(iter) is None:
        
            while modelo.iter_children(iter) is not None:
                modelo.remove(modelo.iter_children(iter))
            if "codigo_despacho" in d.keys():
                recep = DatosDespacho(self.modelo, iter, self.cursor, d["codigo_despacho"],
                                      "", None, self.atras, True, True)
            elif "codigo_embotellado" in d.keys():
                recep = DatosEmbotellado(self.modelo, iter, self.cursor, d["codigo_embotellado"],
                                      "", None, self.atras, True, True)
            elif "codigo_mezcla" in d.keys():
                recep = DatosMezcla(self.modelo, iter, self.cursor, d["codigo_mezcla"],
                                      "", None, self.atras, None, True, True)
            elif "codigo_fermentacion" in d.keys():
                recep = DatosFermentacion(self.modelo, iter, self.cursor, d["codigo_fermentacion"],
                                      "", None, self.atras, True, True)
            elif "codigo_maceracion" in d.keys():
                recep = DatosMaceracion(self.modelo, iter, self.cursor, d["codigo_maceracion"],
                                      "", None, self.atras, True, True)
            elif "codigo_recepcion_uva" in d.keys():
                recep = DatosRecepcionUva(self.modelo, iter, self.cursor, d["codigo_recepcion_uva"],
                                      "", None, self.atras, True, True)
        
    def selection_changed(self, selection):
        
        self.txtTrazabilidad.set_text("")
        cadena = ""
        m, i = selection.get_selected()
        
        try:
            path = m.get_path(i)
            if m.iter_parent(i) is None:
                self.carga_child(self.treeTrazabilidad, i, path)
        except:
            pass
  
        if m is None:
            return
        if i is None:
            return
        d = m.get_value(i, 2)
        try:
            k = d.keys()
        except:
            return
        dg = deglose.Deglose(self.cnx)
        if not self.hacia_atras:
            ta = TrazabilidadAdelante(self.cursor)
            if "codigo_despacho" in d.keys():
                cadena += "Despacho"
                dg.despacho(d["codigo_despacho"])
            if "codigo_embotellado" in d.keys():
                cadena += "Embotellado"
                ta.adelante_embotellado(d['codigo_embotellado'])
                dg.embotellado(d["codigo_embotellado"])
            if "codigo_mezcla" in d.keys():
                cadena += "Mezcla"
                ta.adelante_mezcla(d['codigo_mezcla'])
                dg.mezcla(d['codigo_mezcla'])
            if "codigo_fermentacion" in d.keys():
                cadena +="Fermentación"
                ta.adelante_fermentacion(d['codigo_fermentacion'])
                dg.fermentacion(d['codigo_fermentacion'])
            if "codigo_maceracion" in d.keys():
                cadena +="Maceración"
                ta.adelante_maceracion(d['codigo_maceracion'])
                dg.maceracion(d['codigo_maceracion'])
            if "codigo_recepcion_uva" in d.keys():
                cadena +="Recepción Uva"
                ta.adelante_recepcion(d['codigo_recepcion_uva'])
                dg.recepcion_uva(d['codigo_recepcion_uva'])
            ta.crea_etiqueta(dg.diccionario, dg.volumen)
            cadena += "\n\n%s" % ta.etiqueta
        else:
            cadena = crea_cadena(d, "")
            cadena += "\n"

            p = calcula_detalle_recepcion(m, i, self.hacia_atras, self.cursor)
            total = 0
            datos_totales = {}
            for n in p:
                total += n["porcentaje"] * n["cantidad"]

            for n in p:
                n["porcentaje_del_total_en_la_mezcla"] = ((n["cantidad"] * n["porcentaje"]) / total)*100
                n["total_mezcla"] = total
                n["total_aportado_de_la_recepcion"] = n["cantidad"] * n["porcentaje"]
                n["porcentaje"] = n["porcentaje"] * 100
                if not n["cuartel"] in datos_totales.keys():
                    datos_totales[n["cuartel"]] = n["total_aportado_de_la_recepcion"]
                else:
                    datos_totales[n["cuartel"]] +=  n["total_aportado_de_la_recepcion"]
                
                cadena += crea_cadena_recepcion(n, "")
                cadena += "\n"
            
            cadena += "\n<b>Datos por cuarteles</b>\n"
            for n in datos_totales:
                cadena += "<b>%s</b>: %s Kg.\n" % (n, comunes.CMon(datos_totales[n],2))
                cadena += "<b>%% del total:</b> %s%%\n"  % comunes.CMon(((datos_totales[n]/total)*100),2)
                cadena += "\n"
                
        self.txtTrazabilidad.set_markup(cadena)
    
    def carga_datos(self):
        self.modelo.clear()
        
    def on_btnRefrescar_clicked(self, btn=None):
        self.atras = self.hacia_atras
        self.modelo.clear()
        if len(self.entFiltro.get_text()) > 0 and self.entFiltro.get_text().isdigit():
            codigo = int(self.entFiltro.get_text())
        else:
            codigo = None
        if self.optRecepcionUva.get_active():
            recep = DatosRecepcionUva(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
        if self.optMaceracion.get_active():
            recep = DatosMaceracion(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
        if self.optFermentacion.get_active():
            recep = DatosFermentacion(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
        if self.optMezcla.get_active():
            recep = DatosMezcla(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
        if self.optEmbotellado.get_active():
            recep = DatosEmbotellado(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
        if self.optDespacho.get_active():
            recep = DatosDespacho(self.modelo, None, self.cursor, codigo, hacia_atras=self.hacia_atras)
            
    def on_optAtras_toggled(self, button=None):
        self.hacia_atras = True
        
    def on_optAdelante_toggled(self, button=None):
        self.hacia_atras = False
        
    def trazar(self):
        pass
    
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Arbol de Trazabilidad")
    
    def on_btnInformacion_clicked(self, btn=None):
        self.on_treeTrazabilidad_row_activated()
        
    def on_treeTrazabilidad_row_expanded(self, treeView, iter, tuple):
        
        if self.expand:
            self.carga_child(treeView, iter, tuple)
        self.expand = False
        treeView.expand_row(tuple[0], False)
        self.expand = True
        
    def on_treeTrazabilidad_row_activated(self, patch=None, col=None, tree=None):
        self.planilla = []
        model, it = self.treeTrazabilidad.get_selection().get_selected()
        if model is None or it is None:
            return
        dlg = dlgTrazabilidad(self.cnx, self, False)
        dlg.dlgTrazabilidad.set_size_request(820, 440)
        codigo = model.get_value(it, CODIGO) #IMPORTANTE...
        detalle = model.get_value(it, DETALLE)
        #cadena = "Tipo: "
        #
        #if self.optDespacho.get_active():
        #    cadena += "Despacho"
        #if self.optEmbotellado.get_active():
        #    cadena += "Embotellado"            
        #if self.optMezcla.get_active():
        #    cadena += "Mezcla"
        #if self.optFermentacion.get_active():
        #    cadena +="Fermentacion"
        #if self.optMaceracion.get_active():
        #    cadena +="Maceracion"
        #if self.optRecepcionUva.get_active():
        #    cadena +="Recepción Uva"
        cadena = ""
        cadena += "\nCódigo: "
        cadena += "%s" % codigo
        cadena += "\nDetalle: %s" % detalle
        cadena += "\n\t\tAplicación: \n\t\t\t"
        
        if self.hacia_atras:
            child = model.iter_children(it)
            cadena += self.busca_child(model, child)
            
            
        #manipular aplicacion para que se agrupen :P
        #indice = 0
        #diccionario = {}
        #factura = ""
        #for i in aplicacion:
        #    #if indice > 0:
        #    #    inicio = i.find("Factura: ")
        #    #    fin = i.find(" ", inicio)
        #    #    factura = i[inicio + 9:fin]
        #    #    if diccionario.has_key(factura):
        #    #        diccionario(factura) += peso
        #        
        #    indice += 1
        #    cadena += i
        
        datos_cuartel = self.txtTrazabilidad.get_text()
        datos_cuartel = datos_cuartel[datos_cuartel.find("Datos por cuarteles"):]
        cadena += "\n\n" + datos_cuartel
        buf = dlg.txtTrazabilidad.get_buffer()
        buf.set_text(cadena)
        dlg.txtTrazabilidad.set_buffer(buf)
        
    def busca_child(self, model, child):
        texto = ""
        while child is not None:
            if model.get_value(child, 1) == "Aplicaciones":
                texto += self.busca_aplicaciones(model, child)
            elif model.get_value(child, 1) != "Controles":
                hijo = model.iter_children(child)
                texto += self.busca_child(model, hijo)
            child = model.iter_next(child)
        
        return texto

    def busca_aplicaciones(self, model, child):
        aplicacion = ""
        aplicacion_children = model.iter_children(child)
        while aplicacion_children is not None:
            aplicacion += model.get_value(aplicacion_children, 0)
            aplicacion += model.get_value(aplicacion_children, 1)
            #aplicacion += model.get_value(aplicacion_children, 2)
            self.planilla.append(model.get_value(aplicacion_children, 2))
            aplicacion += "\n\t\t\t"
            
            aplicacion_children = model.iter_next(aplicacion_children)
        
        return aplicacion
class dlgTrazabilidad(GladeConnect):
    def __init__(self, conexion=None, padre=None, cargar=True):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgTrazabilidad")
        self.padre = padre
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.dlgTrazabilidad.set_transient_for(self.padre.frm_padre)
    
    def on_btnCerrar_clicked(self, btn=None):
        self.dlgTrazabilidad.hide()

    def on_btnImprimir_clicked(self, btn=None):
        f = open("traza.csv", "w")
        linea = ""
        llaves = self.padre.planilla[1].keys()
        llaves.sort()
        for i in llaves[:-1]:
            linea += i + ","
        linea += llaves[-1] + "\n"
        f.write(linea)
        for i in self.padre.planilla:
            linea = ""
            for j in llaves:
                linea += str(i[j]) + ","
            linea +=  "\n"
            f.write(linea)    
        f.close()
        return 

        buf = self.txtTrazabilidad.get_buffer()
        s, e = buf.get_bounds()
        html = '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8"><tt>'
        
        html += buf.get_text(s, e).replace("\n", "<br>")
        html += "</tt>"
        
        f = open("reporte.html", "w")
        f.write(html)
        f.close()
        if sys.platform == "win32":
             #os.system("explorer reporte.html")
             subprocess.Popen('explorer reporte.html', shell=True)
        else:
             #os.system("firefox reporte.html")
             subprocess.Popen('firefox reporte.html', shell=True)

if __name__ == "__main__":
    cnx = connect("dbname=traza user=fabio password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = vboxTrazabilidad(cnx, cargar=True)
    
    gtk.main()
